home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume25 / ted / part03 < prev    next >
Encoding:
Text File  |  1991-11-06  |  54.7 KB  |  1,643 lines
  1. Newsgroups: comp.sources.misc
  2. From: dan%step.uucp@uunet.uu.net (Daniel Weaver)
  3. Subject:  v25i028:  ted - Terminfo/termcap test program, Part03/07
  4. Message-ID: <1991Nov6.042934.5924@sparky.imd.sterling.com>
  5. X-Md4-Signature: c510100df33012ac4a57d7ef2f393e9f
  6. Date: Wed, 6 Nov 1991 04:29:34 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: dan%step.uucp@uunet.uu.net (Daniel Weaver)
  10. Posting-number: Volume 25, Issue 28
  11. Archive-name: ted/part03
  12. Environment: UNIX
  13.  
  14. #! /bin/sh
  15. # This is a shell archive.  Remove anything before this line, then feed it
  16. # into a shell via "sh file" or similar.  To overwrite existing files,
  17. # type "sh file -c".
  18. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  19. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  20. # If this archive is complete, you will see the following message at the end:
  21. #        "End of archive 3 (of 7)."
  22. # Contents:  build.c control.c tparam.c
  23. # Wrapped by dan@step on Fri Nov  1 11:28:25 1991
  24. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  25. if test -f 'build.c' -a "${1}" != "-c" ; then 
  26.   echo shar: Will not clobber existing file \"'build.c'\"
  27. else
  28. echo shar: Extracting \"'build.c'\" \(12849 characters\)
  29. sed "s/^X//" >'build.c' <<'END_OF_FILE'
  30. X/*
  31. X** This software is Copyright (c) 1991 by Daniel Weaver.
  32. X**
  33. X** Permission is hereby granted to copy, distribute or otherwise
  34. X** use any part of this package as long as you do not try to make
  35. X** money from it or pretend that you wrote it.  This copyright
  36. X** notice must be maintained in any copy made.
  37. X**
  38. X** Use of this software constitutes acceptance for use in an AS IS
  39. X** condition. There are NO warranties with regard to this software.
  40. X** In no event shall the author be liable for any damages whatsoever
  41. X** arising out of or in connection with the use or performance of this
  42. X** software.  Any use of this software is at the user's own risk.
  43. X**
  44. X**  If you make modifications to this software that you feel
  45. X**  increases it usefulness for the rest of the community, please
  46. X**  email the changes, enhancements, bug fixes as well as any and
  47. X**  all ideas to me. This software is going to be maintained and
  48. X**  enhanced as deemed necessary by the community.
  49. X*/
  50. X#include <stdio.h>
  51. X
  52. X/* Create the files needed to fetch the termcap.
  53. X   This program is designed to run under System V. */
  54. X
  55. Xextern char *boolfnames[], *boolcodes[], *boolnames[];
  56. Xextern char *numfnames[], *numcodes[], *numnames[];
  57. Xextern char *strfnames[], *strcodes[], *strnames[];
  58. X
  59. Xstatic int wc, cpl;
  60. Xstatic FILE *cp, *hp;
  61. X
  62. Xstatic char tc_key[] =
  63. X"kz00kb01cr02bk03ta04bt05kl06kr07ku08kd09kh10EN11PU12PD13ki14kk15LI16LD17kp18ek19ck20pk21mk22nk23ok24";
  64. X
  65. X#define CAP_BOOL 1
  66. X#define CAP_NUM 2
  67. X#define CAP_STR 3
  68. X#define CAP_KEY 4
  69. X
  70. Xstruct remap_list {
  71. X   int type;
  72. X   char *cap_name, *info_name, *address;
  73. X};
  74. X
  75. Xstruct remap_list tc_remap[] = {
  76. X   CAP_STR, "CF", /* vi */ "civis", "cursor_invisible",
  77. X   CAP_STR, "CO",                0, "cursor_on",
  78. X   CAP_STR, "GS", /* as */ "smacs", "enter_alt_charset_mode",
  79. X   CAP_STR, "GE", /* ae */ "rmacs", "exit_alt_charset_mode",
  80. X   CAP_STR, "ct",                0, "color_terminal",
  81. X   CAP_STR,    0,                0, "clear_all_tabs",
  82. X   0, 0, 0, 0};
  83. X
  84. Xstruct remap_list xenix_remap[] = {
  85. X   CAP_STR, "GS", /* as */ "smacs", "enter_alt_charset_mode",
  86. X   CAP_STR, "GE", /* ae */ "rmacs", "exit_alt_charset_mode",
  87. X   CAP_STR,    0,      /* rs1 */ 0, "reset_1string",
  88. X   CAP_STR,    0,      /* rs3 */ 0, "reset_3string",
  89. X   CAP_STR,    0,      /* is1 */ 0, "init_1string",
  90. X   CAP_STR,    0,      /* is3 */ 0, "init_3string",
  91. X   CAP_KEY, "CL",                0, "key_char_left",
  92. X   CAP_KEY, "CW",                0, "key_change_window",
  93. X   CAP_KEY, "EN",                0, "key_send",
  94. X   CAP_KEY, "HM",                0, "key_Home",
  95. X   CAP_KEY, "LD",                0, "key_line_delete",
  96. X   CAP_KEY, "LF",                0, "key_linefeed",
  97. X   CAP_KEY, "NU",                0, "key_next_unlocked_cell",
  98. X   CAP_KEY, "PN",                0, "key_start_print",
  99. X   CAP_KEY, "PD",                0, "key_page_down",
  100. X   CAP_KEY, "PU",                0, "key_page_up",
  101. X   CAP_KEY, "PS",                0, "key_stop_print",
  102. X   CAP_KEY, "RC",                0, "key_recalc",
  103. X   CAP_KEY, "RF",                0, "key_toggle_ref",
  104. X   CAP_KEY, "RT",                0, "key_return",
  105. X   CAP_KEY, "UP",                0, "key_up_arrow",
  106. X   CAP_KEY, "WL",                0, "key_word_left",
  107. X   CAP_KEY, "WR",                0, "key_word_right",
  108. X#ifdef HUH
  109. X   CAP_STR, "MON", /* SA */ "smam", "enter_am_mode",
  110. X   CAP_STR, "MOF", /* RA */ "rmam", "exit_am_mode",
  111. X#endif
  112. X   0, 0, 0, 0};
  113. X
  114. X
  115. Xsend(s)
  116. Xchar *s;
  117. X   {  /* write the data for the .h file */
  118. X      int ls = strlen(s);
  119. X
  120. X      if (wc) fprintf(hp, ",");
  121. X      ++wc;
  122. X      if (wc + ls > 70) {
  123. X            fprintf(hp, "\n");  wc = 0;
  124. X         }
  125. X      fprintf(hp, " %s", s);  wc += ls + 1;
  126. X   }
  127. X
  128. X
  129. Xsend_names(info, cap)
  130. Xchar *info, *cap;
  131. X   {  /* build a string array with the cap and info names */
  132. X      cpl += strlen(info) + strlen(cap) + 5;
  133. X      if (cpl > 70)
  134. X         {
  135. X            fprintf(cp, "\n\t");
  136. X            cpl = strlen(info) + strlen(cap) + 12;
  137. X         }
  138. X      else fprintf(cp, " ");
  139. X      fprintf(cp, "\"%s:%s\",", info, cap);
  140. X   }
  141. X
  142. X
  143. Xremap_keys(def, key)
  144. Xchar *def;
  145. Xstruct remap_list key[];
  146. X   {  /* expand a termcap personality */
  147. X      int i, j;
  148. X
  149. X      fprintf(cp, "#ifdef %s\n", def);
  150. X         for (i = j = 0; key[i].type; ++i) {
  151. X            if (key[i].cap_name) {
  152. X               switch (key[i].type) {
  153. X               case CAP_BOOL:
  154. X                  fprintf(cp, "\t%s = tgetflag(\"%s\");\n",
  155. X                     key[i].address, key[i].cap_name);
  156. X                  break;
  157. X               case CAP_NUM:
  158. X                  fprintf(cp, "\t%s = tgetnum(\"%s\");\n",
  159. X                     key[i].address, key[i].cap_name);
  160. X                  break;
  161. X               case CAP_STR:
  162. X                  fprintf(cp, "\t%s = tgetstr(\"%s\", &bb);\n",
  163. X                     key[i].address, key[i].cap_name);
  164. X                  break;
  165. X               case CAP_KEY:
  166. X                  fprintf(cp,
  167. X                  "    enter_key(\"%s\", %s = tgetstr(\"%s\", &bb));\n",
  168. X                     key[i].cap_name, key[i].address, key[i].cap_name);
  169. X                  break;
  170. X               }
  171. X               if (key[i].info_name) fprintf(cp,
  172. X                  "\tcaptrans[cap_index(\"%s\", %d)] = \"%s:%s\";\n",
  173. X                  key[i].info_name, strlen(key[i].info_name),
  174. X                  key[i].info_name, key[i].cap_name);
  175. X               else {
  176. X                  if (j++ == 0) fprintf(hp, "\n#ifdef %s\n", def);
  177. X                  switch (key[i].type) {
  178. X                  case CAP_BOOL:
  179. X                     fprintf(hp, "EXTERN char %s;\n", key[i].address);
  180. X                     break;
  181. X                  case CAP_NUM:
  182. X                     fprintf(hp, "EXTERN int %s;\n", key[i].address);
  183. X                     break;
  184. X                  case CAP_KEY:
  185. X                  case CAP_STR:
  186. X                     fprintf(hp, "EXTERN CHARSTAR %s;\n", key[i].address);
  187. X                     break;
  188. X                  }
  189. X               }
  190. X            }
  191. X            else /* name is missing.  Clear the value */
  192. X            switch (key[i].type) {
  193. X            case CAP_BOOL:
  194. X               fprintf(cp, "\t%s = 0;\n", key[i].address);
  195. X               break;
  196. X            case CAP_NUM:
  197. X               fprintf(cp, "\t%s = -1;\n", key[i].address);
  198. X               break;
  199. X            case CAP_KEY:
  200. X            case CAP_STR:
  201. X               fprintf(cp, "\t%s = (char *) 0;\n", key[i].address);
  202. X               break;
  203. X            }
  204. X         }
  205. X      fprintf(cp, "#endif\n");
  206. X      if (j) fprintf(hp, "#endif\n");
  207. X   }
  208. X
  209. X
  210. Xmain()
  211. X   {
  212. X      int i, j, k, max_key, tc_def, more_keys;
  213. X
  214. X      if (!(hp = fopen("bsd.h", "w")))
  215. X         {
  216. X            fprintf(stdout, "Can't open bsd.h\n");
  217. X            exit(1);
  218. X         }
  219. X      if (!(cp = fopen("getcaps.c", "w")))
  220. X         {
  221. X            fprintf(stdout, "Can't open getcaps.c\n");
  222. X            exit(1);
  223. X         }
  224. X
  225. X      fprintf(hp, "/* termcap to terminfo conversion */\n\n");
  226. X      fprintf(hp, "#ifdef MAIN\n#define EXTERN\n");
  227. X      fprintf(hp, "#else\n#define EXTERN extern\n#endif\n\n");
  228. X      fprintf(hp, "typedef char *CHARSTAR;\n");
  229. X
  230. X      fprintf(cp, "/* termcap to terminfo conversion */\n");
  231. X      fprintf(cp, "#ifdef TESTCAP\n");
  232. X      fprintf(cp, "#include \"bsd.h\"\n");
  233. X      fprintf(cp, "#ifdef LIBTC\n");
  234. X      fprintf(cp, "#define tgetent tcgetent\n");
  235. X      fprintf(cp, "#define tgetnum tcgetnum\n");
  236. X      fprintf(cp, "#define tgetflag tcgetflag\n");
  237. X      fprintf(cp, "#define tgetstr tcgetstr\n");
  238. X      fprintf(cp, "char ttytype[256];\n");
  239. X      fprintf(cp, "static char *s, *t;\n");
  240. X      fprintf(cp, "extern char *gtname();\n");
  241. X      fprintf(cp, "static int l;\n");
  242. X      fprintf(cp, "#endif\n");
  243. X      fprintf(cp, "extern char *tgetstr();\n");
  244. X      fprintf(cp, "char cap_entry[4096];\n");
  245. X      fprintf(cp, "static char buf[4096];\n");
  246. X      fprintf(cp, "static char *bb = buf;\n");
  247. X      fprintf(cp, "char *captrans[] = {");
  248. X      cpl = 1024;
  249. X         for (i = 0; boolfnames[i]; ++i)
  250. X            send_names(boolnames[i], boolcodes[i]);
  251. X         for (i = 0; numfnames[i]; ++i)
  252. X            send_names(numnames[i], numcodes[i]);
  253. X         for (i = 0; strfnames[i]; ++i)
  254. X            send_names(strnames[i], strcodes[i]);
  255. X      fprintf(cp, " 0};\n");
  256. X      fprintf(cp, "readcaps() {\n\n");
  257. X      fprintf(cp, "    tgetent(cap_entry, getenv(\"TERM\"));\n");
  258. X      fprintf(cp, "#ifdef LIBTC\n");
  259. X      fprintf(cp, "    for (s = cap_entry; *s != '|'; s++)\n");
  260. X      fprintf(cp, "        if (*s == '\\0' | *s == ':') { s = cap_entry; break; }\n");
  261. X      fprintf(cp, "    if (*s == '|') s++;\n");
  262. X      fprintf(cp, "    for (t = ttytype; *t = *s; t++, s++)\n");
  263. X      fprintf(cp, "        if (*t == ':') { *t = '\\0'; break; }\n");
  264. X      fprintf(cp, "#endif\n");
  265. X      fprintf(hp, "\nEXTERN char\n");  wc = 0;
  266. X         for (i = 0; boolfnames[i]; ++i) {
  267. X            send(boolfnames[i]);
  268. X            fprintf(cp, "    %s = tgetflag(\"%s\");\n",
  269. X               boolfnames[i], boolcodes[i]);
  270. X         }
  271. X      send("physical_tabs");  /* no terminfo equivalent */
  272. X      fprintf(cp, "    physical_tabs = tgetflag(\"pt\");\n");
  273. X      fprintf(hp, ";\n\nEXTERN int\n");  wc = 0;
  274. X         for (i = 0; numfnames[i]; ++i) {
  275. X            send(numfnames[i]);
  276. X            if (strcmp(numcodes[i], "it"))
  277. X               {
  278. X                  fprintf(cp, "    %s = tgetnum(\"%s\");\n",
  279. X                  numfnames[i], numcodes[i]);
  280. X               }
  281. X            else
  282. X               {
  283. X                  fprintf(cp, "#ifndef TC\n");
  284. X                  fprintf(cp, "    %s = tgetnum(\"%s\");\n",
  285. X                  numfnames[i], numcodes[i]);
  286. X                  fprintf(cp, "#endif\n");
  287. X               }
  288. X         }
  289. X      fprintf(hp, ";\n\nEXTERN CHARSTAR\n");  wc = 0;
  290. X      fprintf(cp, "#ifdef TC\n");
  291. X         for (i = 0; i < 140; ++i) {
  292. X            j = i / 10;  k = '0' + i % 10;
  293. X            fprintf(cp,
  294. X            "    enter_lab(\"%c%c\", tgetstr(\"%c%c\", &bb), \"%c%c\", tgetstr(\"%c%c\", &bb));\n",
  295. X               'm' + j, k, 'm' + j, k, 'M' + j, k, 'M' + j, k);
  296. X         }
  297. X         for (i = 0; tc_key[i]; i += 4) {
  298. X            fprintf(cp,
  299. X            "    enter_lab(\"%c%c\", tgetstr(\"%c%c\", &bb), \"%c%c\", tgetstr(\"%c%c\", &bb));\n",
  300. X               tc_key[i], tc_key[i + 1], tc_key[i], tc_key[i + 1],
  301. X               tc_key[i + 2], tc_key[i + 3],
  302. X               tc_key[i + 2], tc_key[i + 3]);
  303. X         }
  304. X      fprintf(cp, "#endif\n");
  305. X      max_key = tc_def = 0;
  306. X      more_keys = 1;
  307. X         for (i = 0; strfnames[i]; ++i) {
  308. X            send(strfnames[i]);
  309. X            k = strcodes[i][0];
  310. X            j = strcodes[i][1];
  311. X            if (k == 'k' && ((j >= '0' && j <= '9') || j == ';'))
  312. X               {
  313. X                  if (tc_def) { fprintf(cp, "#endif\n"); tc_def = 0; }
  314. X                  max_key = i;
  315. X                  k = (j == ';') ? 10 : j - '0';
  316. X                  fprintf(cp,
  317. X                  "    enter_lab(\"k%c\", key_f%d = tgetstr(\"k%c\", &bb),\n\t\t\"l%c\", lab_f%d = tgetstr(\"l%c\", &bb));\n",
  318. X                     j, k, j, j, k, j);
  319. X               }
  320. X            else
  321. X            if (more_keys && (strnames[i][0] == 'k' ||
  322. X               (k == 't' && j == 'a')))
  323. X               {
  324. X                  if (tc_def) { fprintf(cp, "#endif\n"); tc_def = 0; }
  325. X                  max_key = i;
  326. X                  fprintf(cp,
  327. X                  "    enter_key(\"%s\", %s = tgetstr(\"%s\", &bb));\n",
  328. X                  strcodes[i], strfnames[i], strcodes[i]);
  329. X                  if (strcmp("tab", strfnames[i]) == 0) more_keys = 0;
  330. X               }
  331. X            else
  332. X               {
  333. X                  /* watch out for TC function keys */
  334. X                  if ((k >= 'm' & k <= 'z') && (j >= '0' & j <= '9'))
  335. X                     {
  336. X                        if (!tc_def) fprintf(cp, "#ifndef TC\n");
  337. X                        tc_def = 1;
  338. X                     }
  339. X                  else
  340. X                  if (tc_def)
  341. X                     {
  342. X                        fprintf(cp, "#endif\n");
  343. X                        tc_def = 0;
  344. X                     }
  345. X                  fprintf(cp, "    %s = tgetstr(\"%s\", &bb);\n",
  346. X                     strfnames[i], strcodes[i]);
  347. X               }
  348. X         }
  349. X      if (tc_def) fprintf(cp, "#endif\n");
  350. X      send("reset_string");  /* terminfo maps it wrong */
  351. X      fprintf(cp, "    reset_string = tgetstr(\"rs\");\n");
  352. X      fprintf(hp, ";\n");
  353. X      remap_keys("TC", tc_remap);
  354. X      remap_keys("XENIX", xenix_remap);
  355. X      fprintf(hp, "\n#define MAX_STRINGS %d\n", i);
  356. X      fprintf(cp, "}\n#endif\n");
  357. X      fprintf(cp, "#ifndef SVR3\n");
  358. X      fprintf(cp, "#ifndef SVR3_2\n");
  359. X      fprintf(cp, "char *strnames[] = {\n\t");
  360. X      j = 8;
  361. X         for (i = 0; i < max_key; ++i) {
  362. X            j += strlen(strnames[i]) + 4;
  363. X            fprintf(cp, "\"%s\"", strnames[i]);
  364. X            if (j > 65)
  365. X               {
  366. X                  fprintf(cp, ",\n    ");
  367. X                  j = 8;
  368. X               }
  369. X            else fprintf(cp, ", ");
  370. X         }
  371. X      fprintf(cp, "0};\n#endif\n");
  372. X      fprintf(cp, "#endif\n");
  373. X      fclose(cp);
  374. X      fclose(hp);
  375. X   }
  376. END_OF_FILE
  377. if test 12849 -ne `wc -c <'build.c'`; then
  378.     echo shar: \"'build.c'\" unpacked with wrong size!
  379. fi
  380. # end of 'build.c'
  381. fi
  382. if test -f 'control.c' -a "${1}" != "-c" ; then 
  383.   echo shar: Will not clobber existing file \"'control.c'\"
  384. else
  385. echo shar: Extracting \"'control.c'\" \(37322 characters\)
  386. sed "s/^X//" >'control.c' <<'END_OF_FILE'
  387. X/*
  388. X** This software is Copyright (c) 1991 by Daniel Weaver.
  389. X**
  390. X** Permission is hereby granted to copy, distribute or otherwise
  391. X** use any part of this package as long as you do not try to make
  392. X** money from it or pretend that you wrote it.  This copyright
  393. X** notice must be maintained in any copy made.
  394. X**
  395. X** Use of this software constitutes acceptance for use in an AS IS
  396. X** condition. There are NO warranties with regard to this software.
  397. X** In no event shall the author be liable for any damages whatsoever
  398. X** arising out of or in connection with the use or performance of this
  399. X** software.  Any use of this software is at the user's own risk.
  400. X**
  401. X**  If you make modifications to this software that you feel
  402. X**  increases it usefulness for the rest of the community, please
  403. X**  email the changes, enhancements, bug fixes as well as any and
  404. X**  all ideas to me. This software is going to be maintained and
  405. X**  enhanced as deemed necessary by the community.
  406. X*/
  407. X/* terminfo test program control subroutines */
  408. X
  409. X#include "curses.h"
  410. X#include "ted.h"
  411. X
  412. Xextern char * malloc();
  413. Xextern char letters[];
  414. X/* CPMS_SHIFT defines the effective range for tty_cpms.
  415. X   Low numbers are more accurate at high baud rates and high numbers
  416. X   must be used for low baud rates.  The number should be in the
  417. X   range of 7 to 11.
  418. X*/
  419. X#define CPMS_SHIFT 11
  420. X#define BUMP_CPMS (1 << (CPMS_SHIFT - 1))
  421. Xstatic int tty_cpms;  /* characters per micro second shifted left CPMS_SHIFT */
  422. X
  423. X#ifdef ACCO
  424. Xextern FILE *fpacco;
  425. X#endif
  426. X
  427. Xstatic void
  428. Xrate_status(tps, test_type, results)
  429. Xchar *tps, *test_type, *results;
  430. X   {  /* display the results of the baud rate test */
  431. X      int j;
  432. X
  433. X      if (has_status_line)
  434. X         {
  435. X            putp(tparm(to_status_line, 0));
  436. X            ptext(test_type);
  437. X            putchp(' ');
  438. X            ptext(results);
  439. X            j = columns - strlen(results) - strlen(test_type) - 2;
  440. X            /* pad the line with blanks */
  441. X               for ( ; --j > 0; ) putchp(' ');
  442. X            putp(from_status_line);
  443. X            home_down();
  444. X            ptext(tps);
  445. X            j = strlen(tps);
  446. X         }
  447. X      else
  448. X         {
  449. X            home_down();
  450. X            ptext(tps);
  451. X            putchp(' ');
  452. X            ptext(results);
  453. X            j = strlen(tps) + strlen(results) + 1;
  454. X         }
  455. X      /* pad the line with blanks */
  456. X         for ( ; ++j < columns; ) putchp(' ');
  457. X   }
  458. X
  459. X
  460. Xvoid
  461. Xfind_baud_rate()
  462. X{  /* calculate the baud rate from the number of characters sent */
  463. X      int j, k, l, sync, upper, test_number;
  464. X      long max_time, test_time;
  465. X      char cur_num[16];
  466. X      static char *test_item[] = {
  467. X         "character", "line feed", "clear"};
  468. X      long max_rate[3];
  469. X      char text_rate[3][16], xxx_per_sec[3][64], summary[3][80];
  470. X
  471. X      upper = test_number = reps = 0;
  472. X      max_rate[0] = max_rate[1] = max_rate[2] = 0;
  473. X      letter = letters[letter_number = 0];
  474. X      max_time = 20;
  475. X      rate_status("begin baud rate search. ", test_item[test_number], "");
  476. X         for (l = 0; l < 3; l++) {
  477. X            xxx_per_sec[l][0] = summary[l][0] = '\0';
  478. X         }
  479. X         for (l = 1; ; ++l) {
  480. X            (void) tty_sync_error();
  481. X            char_sent = ops = 0;
  482. X            start_time = end_time = time(0);
  483. X               for (sync = 0; start_time + max_time >= end_time; ) {
  484. X                  ++sync;
  485. X                  switch (test_number) {
  486. X                  case 0:  /* full screen */
  487. X                     go_home();
  488. X                        for (j = 1; j < lines; j++) {
  489. X                              for (k = 0; k < columns; k++)
  490. X                                 if (k & 0xF) putchp(letter);
  491. X                                 else putchp('.');
  492. X                        }
  493. X                     ops = char_sent;
  494. X                     NEXT_LETTER;
  495. X                     break;
  496. X                  case 1:  /* scroll */
  497. X                     sprintf(temp, "%d", sync);
  498. X                     ptextln(temp);
  499. X                        for (j = 0; j < reps; j++) {
  500. X                           put_ind();
  501. X                        }
  502. X                     ops += reps;
  503. X                     break;
  504. X                  case 2:  /* clear */
  505. X                     sprintf(temp, "%d", sync);
  506. X                     ptext(temp);
  507. X                        for (j = 0; j < reps; j++) {
  508. X                           put_clear();
  509. X                        }
  510. X                     ops += reps;
  511. X                     break;
  512. X                  }
  513. X                  if (sync >= upper)
  514. X                     {
  515. X                        if (tty_sync_error())
  516. X                           {
  517. X                              time_pad = FALSE;
  518. X                              return;
  519. X                           }
  520. X                        end_time = time(0);
  521. X                        if (start_time + max_time <= end_time) break;
  522. X                     }
  523. X               }
  524. X            test_time = end_time - start_time;
  525. X            j = (ops * 10) / test_time;
  526. X            three_digit(cur_num, j);
  527. X            sprintf(xxx_per_sec[test_number], "%s %ss per second.",
  528. X               cur_num, test_item[test_number]);
  529. X            if (test_number == 0)
  530. X               {
  531. X                  tty_baud_rate = j =
  532. X                     ((char_sent >> 1) * tty_frame_size) / test_time;
  533. X                  three_digit(cur_num, j * 10);
  534. X               }
  535. X            if (j > max_rate[test_number])
  536. X               {
  537. X                  max_rate[test_number] = j;
  538. X                  strcpy(text_rate[test_number], cur_num);
  539. X               }
  540. X            sprintf(summary[test_number],
  541. X               "test %d: %d sec. Cur: %s Max: %s",
  542. X               l, end_time - start_time,
  543. X               cur_num, text_rate[test_number]);
  544. X            rate_status(xxx_per_sec[test_number], test_item[test_number],
  545. X               summary[test_number]);
  546. X            if (sync > upper)
  547. X               {
  548. X                  if (upper == 0 && reps != 0 && sync > test_time)
  549. X                     {  /* this should help it converge */
  550. X                        reps = ops / test_time;
  551. X                        sync = test_time + 1;
  552. X                     }
  553. X                  upper = sync;
  554. X                  continue;
  555. X               }
  556. X            j = wait_here();
  557. X            if (j == 'r' | j == 'R') ;
  558. X            else
  559. X            if (j == '>')
  560. X               {
  561. X                  upper *= 2;
  562. X                  max_time *= 2;
  563. X               }
  564. X            else
  565. X            if (j == '<')
  566. X               {
  567. X                  upper = (upper + 1) / 2;
  568. X                  max_time /= 2;
  569. X               }
  570. X            else
  571. X            if (j >= '0' & j <= '2')
  572. X               {
  573. X                  j -= '0';
  574. X                  if (j != test_number)
  575. X                     {
  576. X                        upper = 0;
  577. X                        switch (j) {
  578. X                           case 0:  reps = 0;  break;
  579. X                           case 1:
  580. X                              if (max_rate[j])
  581. X                                 {
  582. X                                    reps = max_rate[j] / 10;
  583. X                                    upper = max_time;
  584. X                                 }
  585. X                              else reps = 100;
  586. X                              break;
  587. X                           case 2:
  588. X                              if (max_rate[j])
  589. X                                 {
  590. X                                    reps = max_rate[j] / 10;
  591. X                                    upper = max_time;
  592. X                                 }
  593. X                              else reps = 10;
  594. X                              break;
  595. X                        }
  596. X                     }
  597. X                  test_number = j;
  598. X                  if (test_number != 0 && xon_xoff == 0)
  599. X                     {
  600. X                        ptext("\nWarning:  Terminal not set for XON/XOFF.");
  601. X                        (void) wait_here();
  602. X                     }
  603. X               }
  604. X            else break;
  605. X            if (test_number == 0) rate_status(xxx_per_sec[test_number],
  606. X               test_item[test_number], summary[test_number]);
  607. X         }
  608. X      tty_baud_rate = max_rate[0];
  609. X      if (has_status_line) putp(dis_status_line);
  610. X      put_clear();
  611. X         for (l = 0; l < 3; l++) {
  612. X            if (xxx_per_sec[l][0])
  613. X               {
  614. X                  ptext(xxx_per_sec[l]);
  615. X                  putchp(' ');
  616. X                  ptextln(summary[l]);
  617. X               }
  618. X         }
  619. X   }
  620. X
  621. X
  622. Xvoid
  623. Xverify_time()
  624. X   {  /* verify that the time tests are ready to run */
  625. X      int i, j;
  626. X      long read_time;
  627. X
  628. X      if (stop_testing) return;
  629. X      maybe_wait(6);
  630. X      fflush(stdout);
  631. X      sleep(1);
  632. X      if (stty_query(TTY_CHAR_MODE))
  633. X         put_str("Hit lower case g to start testing...");
  634. X      else put_str("Hit lower case g and CR to start testing...");
  635. X      i = tty_sync_error();
  636. X      if (i == FALSE) i = getchp(STRIP_PARITY);
  637. X      if (i != 'g')
  638. X         {
  639. X            /* Either the terminal did not respond or the user
  640. X               does not like us.  If the terminal returned nothing
  641. X               then (i & 255) will equal 'g'.  If the terminal
  642. X               returned too many characters then we should scan
  643. X               the input for the 'g'.  If the user refuses to type
  644. X               a 'g' then try to cut him a break.  */
  645. X            tty_can_sync = FALSE;
  646. X            ptext("\nThis program expects the ENQ sequence to be");
  647. X            ptext(" answered with the ACK character.  This will help");
  648. X            ptext(" the program reestablish synchronization when");
  649. X            ptextln(" the terminal is overrun with data."); 
  650. X            ptext("\nENQ sequence: ");  putln(expand(tty_ENQ));
  651. X            ptext("ACK recieved: ");  putln(expand(tty_ACK));
  652. X            sprintf(temp, "Length of ACK %d.  Expected length of ACK %d.",
  653. X               strlen(tty_ACK), junk_chars + 1);
  654. X            ptextln(temp);
  655. X            temp[0] = ACK_char;  temp[1] = '\0';
  656. X            ptext("Terminating character: ");  putln(expand(temp));
  657. X            j = wait_here();
  658. X            if (!stty_query(TTY_CHAR_MODE) || (i & 255) == 'g') return;
  659. X            read_time = time(0);
  660. X               for (i = 1; i < 20 && j != 'g'; i++) {
  661. X                  j = wait_here();
  662. X                  if (time(0) - read_time > 2) break;
  663. X               }
  664. X            return;
  665. X         }
  666. X      tty_can_sync = 2;
  667. X      if (tty_baud_rate == 0)
  668. X         {
  669. X            find_baud_rate();
  670. X            if (tty_baud_rate == 0)
  671. X               {
  672. X                  ptextln("unable to determine baud rate.");
  673. X                  (void) wait_here();
  674. X               }
  675. X         }
  676. X   }
  677. X
  678. X
  679. Xvoid
  680. Xcontrol_init()
  681. X   {  /* called when baud rate or test length changes */
  682. X      if (test_length <= 0) test_length = 1;
  683. X      full_test = ((tty_baud_rate * test_length) / tty_frame_size) << 1;
  684. X      char_max = full_test;
  685. X      /* the following equation should read...
  686. X                (tty_baud_rate << CPMS_SHIFT) + (tty_frame_size / 2) * 5000)
  687. X      tty_cpms = -----------------------------------------------------------
  688. X                                (tty_frame_size / 2) * 10000
  689. X         but I rewrote it to work with integer arithmetic
  690. X      */
  691. X      tty_cpms = ((tty_baud_rate << (CPMS_SHIFT - 2)) + tty_frame_size * 625)
  692. X         / (tty_frame_size * 1250);
  693. X      rated_lines = (lines * tty_baud_rate) / 9600;
  694. X      if (rated_lines < 3) rated_lines = 3;
  695. X      else
  696. X      if (rated_lines > lines) rated_lines = lines;
  697. X   }
  698. X
  699. X
  700. X#ifdef TESTCAP
  701. Xint
  702. Xcap_index(c, l)
  703. Xchar *c;
  704. Xint l;
  705. X   {  /* find the terminfo name in the captrans[] array */
  706. X      int i;
  707. X
  708. X         for (i = 0; captrans[i]; i++) {
  709. X            if (!strncmp(c, captrans[i], l))
  710. X               if (captrans[i][l] == ':') return i;
  711. X         }
  712. X      return -1;
  713. X   }
  714. X
  715. X
  716. Xchar *
  717. Xcap_to_info(c)
  718. Xchar *c;
  719. X   {  /* translate the termcap name to a terminfo name */
  720. X      int i, j;
  721. X      static char tinfo[16];
  722. X
  723. X         for (i = 0; captrans[i]; i++) {
  724. X               for (j = 0; captrans[i][j]; ) {
  725. X                  if (captrans[i][j++] == ':') break;
  726. X               }
  727. X            if (!strcmp(c, &captrans[i][j])) {
  728. X               strncpy(tinfo, captrans[i], j - 1);
  729. X               return tinfo;
  730. X            }
  731. X         }
  732. X      return (char *) 0;
  733. X   }
  734. X
  735. X
  736. Xvoid
  737. Xpad_time(cap, star, plain)
  738. Xchar *cap;
  739. Xint *star, *plain;
  740. X   {  /* return the pad time in tens of miliseconds */
  741. X      int val, dec;
  742. X
  743. X      *star = *plain = 0;
  744. X      if (!cap) return;
  745. X         for (val = dec = 0; *cap; ++cap) {
  746. X            if (*cap >= '0' & *cap <= '9') val = val * 10 + *cap - '0';
  747. X            else
  748. X            if (*cap == '.') dec = 1;
  749. X            else break;
  750. X         }
  751. X      if (!dec) val *= 10;
  752. X      if (*cap == '*') *star = val;
  753. X      else *plain = val;
  754. X   }
  755. X
  756. X
  757. Xchar *
  758. Xliberated(cap)
  759. Xchar *cap;
  760. X   {  /* return the cap without the padding */
  761. X      if (cap)
  762. X         for ( ; *cap; ++cap) {
  763. X            if (*cap != '.' && *cap != '*' &&
  764. X               (*cap < '0' | *cap > '9')) break;
  765. X         }
  766. X      return cap;
  767. X   }
  768. X
  769. X#else  /* terminfo */
  770. X
  771. Xvoid
  772. Xpad_time(cap, star, plain)
  773. Xchar *cap;
  774. Xint *star, *plain;
  775. X   {  /* return the pad time in tens of miliseconds */
  776. X      int dec, i;
  777. X
  778. X      *star = *plain = 0;
  779. X      if (!cap) return;
  780. X         for ( ; *cap; ++cap) {
  781. X            if (*cap == '$' & cap[1] == '<')
  782. X               {
  783. X                  cap += 2;
  784. X                     for (i = dec = 0; ; ++cap) {
  785. X                        if (!*cap) return;
  786. X                        if (*cap >= '0' & *cap <= '9')
  787. X                           i = i * 10 + *cap - '0';
  788. X                        else
  789. X                        if (*cap == '.') dec = 1;
  790. X                        else
  791. X                        if (*cap == '*')
  792. X                           {
  793. X                              if (!dec) i *= 10;
  794. X                              *star += i;
  795. X                              i = 0;
  796. X                           }
  797. X                        else
  798. X                        if (*cap == '>')
  799. X                           {
  800. X                              if (!dec) i *= 10;
  801. X                              *plain += i;
  802. X                              break;
  803. X                           }
  804. X                        else
  805. X                        if (*cap != '/') break;
  806. X                     }
  807. X               }
  808. X               
  809. X         }
  810. X   }
  811. X
  812. X
  813. Xchar *
  814. Xliberated(cap)
  815. Xchar *cap;
  816. X   {  /* return the cap without the padding */
  817. X      static char cb[512];
  818. X      char *ts, *ls;
  819. X
  820. X      cb[0] = '\0';  ls = NULL;
  821. X      if (cap)
  822. X         for (ts = cb; *ts = *cap; ++cap) {
  823. X            if (*cap == '$' && cap[1] == '<') ls = ts;
  824. X            ++ts;
  825. X            if (*cap == '>')
  826. X               if (ls)
  827. X                  {
  828. X                     ts = ls;  ls = NULL;
  829. X                  }
  830. X         }
  831. X      return cb;
  832. X   }
  833. X#endif
  834. X
  835. X
  836. Xint
  837. Xenter_cap(n, v)
  838. Xchar *n, *v;
  839. X   {  /* enter a cap into the cap_list (for time tests) */
  840. X      int i;
  841. X
  842. X      /* find an empty slot */
  843. X         for (i = 0; cap_list[i].value; ++i) {
  844. X            if (i >= CAP_MAX) return -1;
  845. X            if (!strcmp(cap_list[i].value, v))
  846. X               {
  847. X                  if (cap_list[i].name && n &&
  848. X                     strcmp(cap_list[i].name, n)) continue;
  849. X                  if (!cap_list[i].name) cap_list[i].name = n;
  850. X                  return i;
  851. X               }
  852. X         }
  853. X      cap_list[i].value = v;
  854. X      cap_list[i].name = n;
  855. X      cap_list[i].new_star = cap_list[i].new_plain = 32767;
  856. X      pad_time(v, &cap_list[i].cur_star, &cap_list[i].cur_plain);
  857. X      return i;
  858. X   }
  859. X
  860. X
  861. Xvoid
  862. Xprint_cap_list()
  863. X   {  /* print the cap list created by enter_cap() */
  864. X      int i, j, l;
  865. X      char b1[16], b2[16], b3[16], fn[128], *s;
  866. X      FILE *fp;
  867. X
  868. X      sprintf(temp, "Write summary of pad times to ted.%s.  Hit 'x' to abort.", tty_shortname);
  869. X      ptext(temp);
  870. X      i = wait_here();
  871. X      if (i == 'x' | i == 'X') return;
  872. X
  873. X      sprintf(fn, "ted.%s", tty_shortname);
  874. X      if (!(fp = fopen(fn, "w"))) return;
  875. X
  876. X         for (i = 0; cap_list[i].value; ++i) {
  877. X            if (cap_list[i].cur_star == 0) b1[0] = '\0';
  878. X            else sprintf(b1, "%3d.%d*",
  879. X               cap_list[i].cur_star / 10,
  880. X               cap_list[i].cur_star % 10);
  881. X            if (cap_list[i].new_plain == 32767) b2[0] = '\0';
  882. X            else sprintf(b2, "%3d.%d",
  883. X               cap_list[i].new_plain / 10,
  884. X               cap_list[i].new_plain % 10);
  885. X            if (cap_list[i].new_star == 32767) b3[0] = '\0';
  886. X            else sprintf(b3, "%3d.%d*",
  887. X               cap_list[i].new_star / 10,
  888. X               cap_list[i].new_star % 10);
  889. X            if (cap_list[i].name)
  890. X               {
  891. X                  s = cap_list[i].name;
  892. X#ifdef TESTCAP
  893. X                  l = strlen(s);
  894. X                  j = cap_index(s, l);
  895. X                  if (j >= 0) s = &captrans[j][l + 1];
  896. X#endif
  897. X               }
  898. X            else s = "";
  899. X            sprintf(temp, "%-5s %3d.%d %6s %5s %6s %s", s,
  900. X               cap_list[i].cur_plain / 10,
  901. X               cap_list[i].cur_plain % 10,
  902. X               b1, b2, b3, print_expand(cap_list[i].value));
  903. X            fprintf(fp, "%s\n", temp);
  904. X         }
  905. X      fclose(fp);
  906. X   }
  907. X
  908. X
  909. Xint
  910. Xbegin_pad_char(clr)
  911. Xint clr;
  912. X   {  /* handle beginning of test response character */
  913. X      int ch;
  914. X
  915. X         while (1) {
  916. X            ch = wait_here();
  917. X            if (ch == 'q' || ch == 'Q')
  918. X               {
  919. X                  ptext("Enter Y to quit:");
  920. X                  ch = wait_here();
  921. X                  if (ch == 'y' || ch == 'Y')
  922. X                     {
  923. X                        stop_testing = TRUE;
  924. X                        return FALSE;
  925. X                     }
  926. X               }
  927. X            else
  928. X            if (ch == 'c' || ch == 'C')
  929. X               {
  930. X                  put_clear();
  931. X                  continue;
  932. X               }
  933. X            else
  934. X            if (ch == '>') test_length *= 2;
  935. X            else
  936. X            if (ch == '<') test_length /= 2;
  937. X            else
  938. X               {
  939. X                  if (clr) put_clear();
  940. X                  char_count = 0;
  941. X                  start_time = time(0);
  942. X                  return (ch != 'n' && ch != 'N');
  943. X               }
  944. X            control_init();
  945. X            sprintf(temp, "\nPad test will run %d seconds.",
  946. X               test_length);
  947. X            ptext(temp);
  948. X         }
  949. X   }
  950. X
  951. X
  952. Xvoid
  953. Xkotex()
  954. X   {  /* change the pads for the current test */
  955. X      int i, v, ch, star, slash, change, dot;
  956. X      char *value;
  957. X
  958. X      put_clear();
  959. X         for (i = 0; i < EDIT_MAX; i++) {
  960. X            if (ced_name[i] && ced_value[i])
  961. X               {
  962. X                  sprintf(temp, "(%s) %s", ced_name[i], expand(*ced_value[i]));
  963. X                  ptextln(temp);
  964. X               }
  965. X         }
  966. X      if (line_count == 0)
  967. X         {
  968. X            ptext("No valid entry for edit.");
  969. X            (void) wait_here();
  970. X            return;
  971. X         }
  972. X      ptextln("Enter new pads.  0 for no pad.  CR for no change.");
  973. X         for (i = 0; i < EDIT_MAX; i++) {
  974. X            if (ced_name[i] && ced_value[i])
  975. X               {
  976. X                  sprintf(temp, "\n(%s) ", ced_name[i]);
  977. X                  ptext(temp);
  978. X                  star = slash = change = FALSE;
  979. X                  dot = 0;
  980. X                     for (v = 0; ch = getchp(STRIP_PARITY); ) {
  981. X                        if (ch >= '0' & ch <= '9')
  982. X                           {
  983. X                              v = ch - '0' + v * 10;
  984. X                              if (dot) dot++;
  985. X                           }
  986. X                        else
  987. X                        if (ch == '*') star = TRUE;
  988. X#ifndef TESTCAP
  989. X                        else
  990. X                        if (ch == '/') slash = TRUE;
  991. X                        else
  992. X                        if (ch == '.') dot = 1;
  993. X#endif
  994. X                        else break;
  995. X                        change = TRUE;
  996. X                        if (stty_query(TTY_NOECHO)) putch(ch);
  997. X                     }
  998. X                  if (!change) continue;
  999. X                     while (dot > 2) {
  1000. X                        v /= 10;
  1001. X                        dot--;
  1002. X                     }
  1003. X                  if (v == 0) strcpy(temp, liberated(*ced_value[i]));
  1004. X                  else
  1005. X#ifdef TESTCAP
  1006. X                     sprintf(temp, "%d%s%s", v, star ? "*" : "",
  1007. X                        liberated(*ced_value[i]));
  1008. X#else
  1009. X                  if (dot == 2)
  1010. X                     sprintf(temp, "%s$<%d.%d%s%s>",
  1011. X                        liberated(*ced_value[i]), v / 10,
  1012. X                        v % 10, star ? "*" : "", slash ? "/" : "");
  1013. X                  else
  1014. X                     sprintf(temp, "%s$<%d%s%s>",
  1015. X                        liberated(*ced_value[i]),
  1016. X                        v, star ? "*" : "", slash ? "/" : "");
  1017. X#endif
  1018. X                  if (value = malloc(strlen(temp) + 1))
  1019. X                     strcpy(value, temp);
  1020. X                  strcpy(temp, liberated(*ced_value[i]));
  1021. X                  *ced_value[i] = value;
  1022. X
  1023. X                  if (temp[0] == '\0')
  1024. X#ifdef TESTCAP
  1025. X                     value = "";
  1026. X#else
  1027. X                     value = "$<>";
  1028. X#endif
  1029. X                  else
  1030. X                     {
  1031. X                        if (value = malloc(strlen(temp) + 1))
  1032. X                           strcpy(value, temp);
  1033. X                     }
  1034. X                  ch = enter_cap(ced_name[i], value);
  1035. X                  if (dot != 2) v *= 10;
  1036. X                  if (star) cap_list[ch].new_star = v;
  1037. X                  else cap_list[ch].new_plain = v;
  1038. X                  write_ted_file = TRUE;
  1039. X               }
  1040. X         }
  1041. X   }
  1042. X
  1043. X
  1044. Xint
  1045. Xend_pad_char(clr)
  1046. Xint clr;
  1047. X   {  /* process the character(s) at the end of a test */
  1048. X      /* return FALSE if end of loop */
  1049. X      int ch;
  1050. X      static char *help[] = {
  1051. X          "c  -  continue",
  1052. X          "d  -  double the number of lines (or characters)",
  1053. X          "h  -  cut number of lines (or characters) in half",
  1054. X          "i  -  send the reset and init strings",
  1055. X          "p  -  change the padding for this capibility",
  1056. X          "q  -  quit (prompts for verification)",
  1057. X          "r  -  rerun test",
  1058. X          "n  -  go on to next test",
  1059. X          "?  -  print this help message",
  1060. X          "<  -  decrease the time for each test",
  1061. X          ">  -  increase the time for each test",
  1062. X          "<number> - change the number of lines (or characters)",
  1063. X          0};
  1064. X
  1065. X      ch = wait_here();
  1066. X      set_attr(0);  /* just in case */
  1067. X         for ( ; ; ) {
  1068. X            switch (ch) {
  1069. X            case '?':
  1070. X                  for (ch = 0; help[ch]; ch++) {
  1071. X                     ptextln(help[ch]);
  1072. X                  }
  1073. X               sprintf(temp, "Tests will affect %d lines (or characters).",
  1074. X                  augment);
  1075. X               ptextln(temp);
  1076. X               sprintf(temp, "Tests will run %d seconds.", test_length);
  1077. X               ptextln(temp);
  1078. X               if (debug_level > 0)
  1079. X                  {
  1080. X                     sprintf(temp, "cpms = %f %d, pad_sent=%d, milli_pad=%d ",
  1081. X                        (float)tty_cpms / (float)(1 << CPMS_SHIFT), tty_cpms,
  1082. X                        pad_sent, milli_pad);
  1083. X                     ptextln(temp);
  1084. X                     sprintf(temp, "OUTPUT TRANS %d, NOECHO %d, CHAR MODE %d",
  1085. X                        stty_query(TTY_OUT_TRANS) != 0,
  1086. X                        stty_query(TTY_NOECHO) != 0,
  1087. X                        stty_query(TTY_CHAR_MODE) != 0);
  1088. X                     ptextln(temp);
  1089. X                  }
  1090. X
  1091. X               /* in case the "Done" gets eaten */
  1092. X               ptext(done_test);
  1093. X               break;
  1094. X            case '>':
  1095. X            case '<':
  1096. X               if (ch == '>') test_length *= 2;
  1097. X               else test_length /= 2;
  1098. X               control_init();
  1099. X               sprintf(temp, "\nPad test will run %d seconds.",
  1100. X                  test_length);
  1101. X               ptext(temp);
  1102. X               break;
  1103. X            case 'C':
  1104. X               put_clear();
  1105. X            case 'c':
  1106. X               /* continue */
  1107. X               break;
  1108. X            case 'd':
  1109. X            case 'D':
  1110. X               /* double the test augment */
  1111. X               augment *= 2;
  1112. X               sprintf(temp, "\nPad test will affect %d lines (or characters).",
  1113. X                  augment);
  1114. X               ptext(temp);
  1115. X               break;
  1116. X            case 'h':
  1117. X            case 'H':
  1118. X               /* cut the test augment in half */
  1119. X               augment /= 2;
  1120. X               sprintf(temp, "\nPad test will affect %d lines (or characters).",
  1121. X                  augment);
  1122. X               ptext(temp);
  1123. X               break;
  1124. X            case 'i':
  1125. X            case 'I':
  1126. X               /* send the reset and init strings */
  1127. X               reset_init(TRUE);
  1128. X               putp(exit_insert_mode);
  1129. X               replace_mode = 1;
  1130. X               put_mode(exit_attribute_mode);
  1131. X               break;
  1132. X            case '0': case '1': case '2': case '3': case '4':
  1133. X            case '5': case '6': case '7': case '8': case '9':
  1134. X               /* read a new test augment */
  1135. X               augment = 0;
  1136. X                  while(ch >= '0' & ch <= '9')
  1137. X                     {
  1138. X                        if (stty_query(TTY_NOECHO)) putch(ch);
  1139. X                        augment = ch - '0' + augment * 10;
  1140. X                        ch = getchp(STRIP_PARITY);
  1141. X                     }
  1142. X               sprintf(temp, "\nPad test will affect %d lines (or characters).",
  1143. X                  augment);
  1144. X               ptext(temp);
  1145. X               break;
  1146. X            case 'p':
  1147. X            case 'P':
  1148. X               kotex();
  1149. X               break;
  1150. X            case 'q':
  1151. X            case 'Q':
  1152. X               ptext("Enter Y to quit:");
  1153. X               ch = wait_here();
  1154. X               if (ch == 'y' || ch == 'Y')
  1155. X                  {
  1156. X                     stop_testing = TRUE;
  1157. X                     return FALSE;
  1158. X                  }
  1159. X               break;
  1160. X            case 'r':
  1161. X            case 'R':
  1162. X               if (augment < 1) augment = 1;
  1163. X               char_max = full_test;
  1164. X               put_clear();
  1165. X               char_sent = 0;
  1166. X               if (time_pad) return enq_ack();
  1167. X               start_time = time(0);
  1168. X               return TRUE;
  1169. X            case 'n':
  1170. X            case 'N':
  1171. X               skip_next = TRUE;
  1172. X            default:
  1173. X               if (clr) put_clear();
  1174. X               return FALSE;
  1175. X            }
  1176. X            ptext("\nHit (c,d,h,i,n,p,q,r,<,>,?,<number>,CR) ");
  1177. X            ch = wait_here();
  1178. X         }
  1179. X   }
  1180. X
  1181. X
  1182. Xint
  1183. Xrun_test(cap, msg, acknowledge)
  1184. Xchar *cap, *msg;
  1185. Xint acknowledge;
  1186. X   {  /* used to begin execution of a string capibility test */
  1187. X      char *s;
  1188. X
  1189. X      if (msg)
  1190. X         {
  1191. X            /* look the for first cap */
  1192. X               for (s = msg; *s && *s != '('; s++);
  1193. X            can_test(s);
  1194. X         }
  1195. X      if (stop_testing) return FALSE;
  1196. X      if (cap) return TRUE;
  1197. X      if (msg)
  1198. X         {
  1199. X            ptextln(msg);
  1200. X            if (acknowledge) (void) wait_here();
  1201. X         }
  1202. X      return FALSE;
  1203. X   }
  1204. X
  1205. X
  1206. Xint
  1207. Xrun_mode(caps)
  1208. Xchar *caps;
  1209. X   {  /* used to begin execution of a boolean or numeric capibility */
  1210. X      can_test(caps);
  1211. X      if (stop_testing) return FALSE;
  1212. X      return TRUE;
  1213. X   }
  1214. X
  1215. X
  1216. Xint
  1217. Xrepeat_test(clr)
  1218. Xint clr;
  1219. X   {  /* used to end a test */
  1220. X      int ch;
  1221. X
  1222. X      if (stop_testing) return FALSE;
  1223. X         for ( ; ; ) {
  1224. X            switch (ch = wait_here()) {
  1225. X            case 'C':
  1226. X               put_clear();
  1227. X            case 'c':
  1228. X               /* continue */
  1229. X               break;
  1230. X            case 'i':
  1231. X            case 'I':
  1232. X               /* send the reset and init strings */
  1233. X               reset_init(TRUE);
  1234. X               putp(exit_insert_mode);
  1235. X               replace_mode = 1;
  1236. X               put_mode(exit_attribute_mode);
  1237. X               break;
  1238. X            case 'q':
  1239. X            case 'Q':
  1240. X               ptext("Enter Y to quit:");
  1241. X               ch = wait_here();
  1242. X               if (ch == 'y' || ch == 'Y')
  1243. X                  {
  1244. X                     stop_testing = TRUE;
  1245. X                     return FALSE;
  1246. X                  }
  1247. X               break;
  1248. X            case 'r':
  1249. X            case 'R':
  1250. X               put_clear();
  1251. X               return TRUE;
  1252. X            case 'n':
  1253. X            case 'N':
  1254. X               skip_next = TRUE;
  1255. X            default:
  1256. X               if (clr) put_clear();
  1257. X               return FALSE;
  1258. X            }
  1259. X            ptext("\nHit (c,i,n,q,r,CR) ");
  1260. X         }
  1261. X   }
  1262. X
  1263. X
  1264. Xvoid
  1265. Xshort_subject(r)
  1266. Xint r;
  1267. X   {  /* set the value of pad_sent */
  1268. X      /* acco_pad() accumulates the pad counts in milli_reps and
  1269. X         milli_pad, then short_subject() converts them to characters and
  1270. X         stores the result in pad_sent.  Note: milli_pad and milli_rep
  1271. X         are in tenths of a milli-second. */
  1272. X
  1273. X      pad_sent = 0;
  1274. X      if (xon_xoff | no_pad_char) pad_sent = ((milli_pad + milli_reps * r)
  1275. X         * tty_cpms + BUMP_CPMS) >> CPMS_SHIFT;
  1276. X   }
  1277. X
  1278. X
  1279. Xint
  1280. Xacco_pad(name, cap)
  1281. Xchar *name, *cap;
  1282. X{  /* ajust the length of the pad test if the user has XON/XOFF set */
  1283. X      int p;
  1284. X
  1285. X      if ((p = enter_cap(name, cap)) != -1)
  1286. X         {
  1287. X            milli_reps += cap_list[p].cur_star;
  1288. X            milli_pad += cap_list[p].cur_plain;
  1289. X         }
  1290. X      short_subject(1);
  1291. X      return TRUE;
  1292. X}
  1293. X
  1294. X
  1295. Xint
  1296. Xbegin_test(cap, name, long_name, alt, clr)
  1297. Xchar **cap, *name, *long_name, *alt;
  1298. Xint clr;
  1299. X   {  /* clear the screen and start the test (special case) */
  1300. X      int ch;
  1301. X
  1302. X      can_test(name);  can_test(alt);
  1303. X      if (stop_testing) return FALSE;
  1304. X      if (cap_select && strcmp(cap_select, name))
  1305. X         if (!alt || (strcmp(cap_select, alt) != 0)) return FALSE;
  1306. X      if (resume_testing) cap_select = NULL;
  1307. X      if (*cap)
  1308. X         {
  1309. X               for (ch = 0; ch < EDIT_MAX; ced_name[ch++] = NULL);
  1310. X            ced_value[0] = cap;
  1311. X            ced_name[0] = name;
  1312. X            letter = letters[letter_number = 0];
  1313. X            put_clear();
  1314. X            clear_select = -1;
  1315. X            char_max = full_test;
  1316. X            rerun = FALSE;
  1317. X            reps = ops = test_count = milli_pad = milli_reps = 0;
  1318. X            sprintf(done_test, "Done. (%s)", current_test = name);
  1319. X            capper = enter_cap(current_test, *cap);
  1320. X            (void) acco_pad(name, *cap);
  1321. X            if (time_pad) return enq_ack();
  1322. X            sprintf(temp,
  1323. X            "Begin (%s) pad test, hit CR to continue, n to skip test",
  1324. X               name);
  1325. X            ptext(temp);
  1326. X            return begin_pad_char(clr);
  1327. X         }
  1328. X      sprintf(temp, "(%s) %s, not present", name, long_name);
  1329. X      ptextln(temp);
  1330. X      if (!time_pad)
  1331. X         {
  1332. X            ch = wait_here();
  1333. X            if (ch == 'c' || ch == 'C') put_clear();
  1334. X         }
  1335. X      return FALSE;
  1336. X   }
  1337. X
  1338. X
  1339. Xint
  1340. Xmulti_test(error_name, clr, or_bits, and_bits, acco_bits, num_caps,
  1341. X   cn1, cv1, cn2, cv2, cn3, cv3, cn4, cv4)
  1342. Xint clr, or_bits, and_bits, acco_bits, num_caps;
  1343. Xchar *error_name;
  1344. Xchar *cn1, *cn2, *cn3, *cn4;
  1345. Xchar **cv1, **cv2, **cv3, **cv4;
  1346. X   {  /* clear the screen and start the test (general case) */
  1347. X      int ch, i, or_flag, and_flag, select_flag;
  1348. X      static char name_buffer[128];
  1349. X
  1350. X      ced_name[0] = cn1;  ced_name[1] = cn2;
  1351. X      ced_name[2] = cn3;  ced_name[3] = cn4;
  1352. X      ced_value[0] = cv1;  ced_value[1] = cv2;
  1353. X      ced_value[2] = cv3;  ced_value[3] = cv4;
  1354. X         for (i = 0; i < num_caps; i++) {
  1355. X            can_test(ced_name[i]);
  1356. X         }
  1357. X      if (stop_testing) return FALSE;
  1358. X      test_count = milli_pad = milli_reps = 0;
  1359. X      or_flag = or_bits & 1;
  1360. X      and_flag = and_bits & 1;
  1361. X      select_flag = !cap_select;
  1362. X      name_buffer[0] = '\0';
  1363. X      ch = 0;
  1364. X#ifdef ACCO
  1365. X      fprintf(fpacco, "(");
  1366. X      if (or_flag)
  1367. X         fprintf(fpacco, "TRUE");
  1368. X      else
  1369. X         for (i = 0; i < num_caps; i++) {
  1370. X            if ((or_bits >> i) & 2)
  1371. X               {
  1372. X                  fprintf(fpacco, "%s", ced_name[i]);
  1373. X                  if ((or_bits >> i) & -4) fprintf(fpacco, "|");
  1374. X               }
  1375. X         }
  1376. X      fprintf(fpacco, ")|(");
  1377. X      if (and_flag)
  1378. X         for (i = 0; i < num_caps; i++) {
  1379. X            if ((and_bits >> i) & 2)
  1380. X               {
  1381. X                  fprintf(fpacco, "%s", ced_name[i]);
  1382. X                  if ((and_bits >> i) & -4) fprintf(fpacco, "&");
  1383. X               }
  1384. X         }
  1385. X      else
  1386. X         fprintf(fpacco, "FALSE");
  1387. X      fprintf(fpacco, ") ACCO(");
  1388. X         for (i = 0; i < num_caps; i++) {
  1389. X            if ((acco_bits >> i) & 2)
  1390. X               {
  1391. X                  fprintf(fpacco, "%s", ced_name[i]);
  1392. X                  if ((acco_bits >> i) & -4) fprintf(fpacco, "+");
  1393. X               }
  1394. X         }
  1395. X      fprintf(fpacco, ") %s\n", error_name ? error_name : "");
  1396. X#endif
  1397. X         for (i = 0; i < num_caps; i++) {
  1398. X            if ((or_bits >> i) & 2)
  1399. X               or_flag |= *ced_value[i] != NULL;
  1400. X            if ((and_bits >> i) & 2)
  1401. X               and_flag &= *ced_value[i] != NULL;
  1402. X            if (*ced_value[i] && ((acco_bits >> i) & 2))
  1403. X               {
  1404. X                  ++ch;
  1405. X                  capper = enter_cap(ced_name[i], *ced_value[i]);
  1406. X                  (void) acco_pad(ced_name[i], *ced_value[i]);
  1407. X               }
  1408. X            if (cap_select)
  1409. X               select_flag |= strcmp(cap_select, ced_name[i]) == 0;
  1410. X            sprintf(&name_buffer[strlen(name_buffer)], "(%s) ", ced_name[i]);
  1411. X         }
  1412. X      if (!select_flag) return FALSE;
  1413. X      if (resume_testing) cap_select = NULL;
  1414. X      if (or_flag | and_flag)
  1415. X         {
  1416. X               for (i = num_caps; i < EDIT_MAX; ced_name[i++] = NULL);
  1417. X            sprintf(done_test, "Done. %s", current_test = name_buffer);
  1418. X            letter = letters[letter_number = 0];
  1419. X            put_clear();
  1420. X            clear_select = -1;
  1421. X            char_max = full_test;
  1422. X            reps = ops = 0;
  1423. X            rerun = FALSE;
  1424. X            if (ch != 1) capper = -1;
  1425. X            if (time_pad) return enq_ack();
  1426. X            put_str("Begin ");  ptext(name_buffer);
  1427. X            ptext("pad test, hit CR to continue, n to skip test");
  1428. X            return begin_pad_char(clr);
  1429. X         }
  1430. X      ptext(error_name);
  1431. X      ptextln(", not present");
  1432. X      if (!time_pad)
  1433. X         {
  1434. X            ch = wait_here();
  1435. X            if (ch == 'c' || ch == 'C') put_clear();
  1436. X         }
  1437. X      return FALSE;
  1438. X   }
  1439. X
  1440. X
  1441. Xstatic int
  1442. Xtime_test_state(clr)
  1443. Xint clr;
  1444. X   {   /* calculate and report the suggested pad times */
  1445. X      long v;
  1446. X
  1447. X      /* time is one of the things that UNIX does poorly.
  1448. X         So I fuss around with sloppy numbers. */
  1449. X      v = end_time - start_time -
  1450. X         ((char_sent >> 1) * tty_frame_size) / tty_baud_rate;
  1451. X      if (v <= 1 && !rerun) return 0;
  1452. X      if (capper == -2)
  1453. X         {  /* truely brain damaged terminals come here */
  1454. X            v = ((char_sent >> 1) * tty_frame_size)
  1455. X                / (end_time - start_time);
  1456. X            sprintf(temp, "This terminal has a maximum effective baud rate of %d. ", v);
  1457. X            ptext(temp);
  1458. X            ptext(" System load may be to high. ");
  1459. X            ptextln(" The results of this test will be incorrect!");
  1460. X            return 2;
  1461. X         }
  1462. X      else
  1463. X         {
  1464. X            if (ops) v = (v * 10000 + ops / 2) / ops;
  1465. X            if (capper == -1) put_str("combined");
  1466. X            else
  1467. X               {
  1468. X                  sprintf(temp, "(%s)", cap_list[capper].name);
  1469. X                  ptext(temp);
  1470. X               }
  1471. X            put_dec(" pad time should be %d.%d milliseconds", v);
  1472. X
  1473. X            if (reps)
  1474. X               {
  1475. X                  sprintf(temp, " for %d reps.", reps);
  1476. X                  ptextln(temp);
  1477. X                  put_dec("%d.%d* milliseconds per rep", v / reps);
  1478. X               }
  1479. X            put_crlf();
  1480. X
  1481. X            if (capper >= 0)
  1482. X               {
  1483. X                  if (milli_pad < cap_list[capper].new_plain)
  1484. X                     cap_list[capper].new_plain = v;
  1485. X                  if (reps != 0 &&
  1486. X                     v / reps < cap_list[capper].new_star)
  1487. X                     cap_list[capper].new_star = v / reps;
  1488. X                  /* if the terminal makes it here once
  1489. X                     then we want to report each time.
  1490. X                     This forces a smaller number into
  1491. X                     the tables.  */
  1492. X                  rerun = TRUE;
  1493. X               }
  1494. X            if (milli_reps != 0 && reps != 0)
  1495. X               {
  1496. X                  ptext("current value is ");
  1497. X                  if (milli_pad)
  1498. X                     put_dec("%d.%d milliseconds and ",
  1499. X                     milli_pad);
  1500. X                  put_dec("%d.%d* milliseconds per rep",
  1501. X                     milli_reps);
  1502. X               }
  1503. X            else put_dec("current value is %d.%d milliseconds", milli_pad);
  1504. X            put_crlf();
  1505. X            if (clear_select != -1)
  1506. X               {
  1507. X                  clr_test_value[clear_select] = v;
  1508. X                  clr_test_reps[clear_select] = reps;
  1509. X               }
  1510. X         }
  1511. X      return 0;
  1512. X   }
  1513. X
  1514. X
  1515. Xint
  1516. Xend_test(txt, clr)
  1517. Xchar *txt;
  1518. Xint clr;
  1519. X   {  /* This code is executed at the bottom of each test to print
  1520. X         the "Done" message and control the looping of tests */
  1521. X      int sync_error;
  1522. X
  1523. X      test_count++;
  1524. X      if (char_sent < char_max) return TRUE;
  1525. X      if (txt) ptext(txt);
  1526. X      cap_tested = 1;
  1527. X      sync_error = 0;
  1528. X      if (tty_can_sync) sync_error = tty_sync_error();
  1529. X      if (xon_xoff && sync_error == 0 && test_length >= 10)
  1530. X         {
  1531. X            end_time = time(0);
  1532. X            ptext(done_test);
  1533. X            switch (time_test_state(clr)) {
  1534. X               case 0:
  1535. X                  if (time_pad) return FALSE;
  1536. X                  break;
  1537. X               case 1:
  1538. X                  if (time_pad) return TRUE;
  1539. X                  break;
  1540. X               case 2:
  1541. X                  break;
  1542. X               }
  1543. X         }
  1544. X      else ptext(done_test);
  1545. X      ops = 0;
  1546. X      return end_pad_char(clr);
  1547. X   }
  1548. X
  1549. X
  1550. Xvoid
  1551. Xpage_loop()
  1552. X   {  /* send CR/LF or go home and bump letter */
  1553. X      if (line_count + 2 >= lines)
  1554. X         {
  1555. X            NEXT_LETTER;
  1556. X            go_home();
  1557. X         }
  1558. X      else put_crlf();
  1559. X   }
  1560. END_OF_FILE
  1561. if test 37322 -ne `wc -c <'control.c'`; then
  1562.     echo shar: \"'control.c'\" unpacked with wrong size!
  1563. fi
  1564. # end of 'control.c'
  1565. fi
  1566. if test -f 'tparam.c' -a "${1}" != "-c" ; then 
  1567.   echo shar: Will not clobber existing file \"'tparam.c'\"
  1568. else
  1569. echo shar: Extracting \"'tparam.c'\" \(1473 characters\)
  1570. sed "s/^X//" >'tparam.c' <<'END_OF_FILE'
  1571. X/*
  1572. X** This software is Copyright (c) 1991 by Daniel Weaver.
  1573. X**
  1574. X** Permission is hereby granted to copy, distribute or otherwise
  1575. X** use any part of this package as long as you do not try to make
  1576. X** money from it or pretend that you wrote it.  This copyright
  1577. X** notice must be maintained in any copy made.
  1578. X**
  1579. X** Use of this software constitutes acceptance for use in an AS IS
  1580. X** condition. There are NO warranties with regard to this software.
  1581. X** In no event shall the author be liable for any damages whatsoever
  1582. X** arising out of or in connection with the use or performance of this
  1583. X** software.  Any use of this software is at the user's own risk.
  1584. X**
  1585. X**  If you make modifications to this software that you feel
  1586. X**  increases it usefulness for the rest of the community, please
  1587. X**  email the changes, enhancements, bug fixes as well as any and
  1588. X**  all ideas to me. This software is going to be maintained and
  1589. X**  enhanced as deemed necessary by the community.
  1590. X*/
  1591. X
  1592. X/*
  1593. X** This subroutine should be tparm() as written by the Free Software Foundation.
  1594. X** But the nice folks at FSF would not let me give it away free.
  1595. X** The version I use for my testing was lifted from emacs and I recommend
  1596. X** that you do the same.  FSF should change its name to the Free Lunch
  1597. X** Foundation.
  1598. X**
  1599. X** System V users can deep 6 this file all together.
  1600. X*/
  1601. X#ifdef TESTCAP
  1602. Xextern char *tgoto();
  1603. X
  1604. Xchar *
  1605. Xtparm(cap, a, b)
  1606. Xchar *cap;
  1607. Xint a, b;
  1608. X{
  1609. X    if (cap) return tgoto(cap, b, a);
  1610. X    return "";
  1611. X}
  1612. X#endif
  1613. END_OF_FILE
  1614. if test 1473 -ne `wc -c <'tparam.c'`; then
  1615.     echo shar: \"'tparam.c'\" unpacked with wrong size!
  1616. fi
  1617. # end of 'tparam.c'
  1618. fi
  1619. echo shar: End of archive 3 \(of 7\).
  1620. cp /dev/null ark3isdone
  1621. MISSING=""
  1622. for I in 1 2 3 4 5 6 7 ; do
  1623.     if test ! -f ark${I}isdone ; then
  1624.     MISSING="${MISSING} ${I}"
  1625.     fi
  1626. done
  1627. if test "${MISSING}" = "" ; then
  1628.     echo You have unpacked all 7 archives.
  1629.     rm -f ark[1-9]isdone
  1630. else
  1631.     echo You still need to unpack the following archives:
  1632.     echo "        " ${MISSING}
  1633. fi
  1634. ##  End of shell archive.
  1635. exit 0
  1636.  
  1637. exit 0 # Just in case...
  1638. -- 
  1639. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1640. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1641. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1642. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1643.